namespace ext
{
	using System;
	using System.Runtime.CompilerServices;
	using System.Html;
	using System.Collections;
	
	
	/// <summary>
	/// Provides a registry of all Components (instances of {@link Ext.Component} or any subclass
	/// thereof) on a page so that they can be easily accessed by {@link Ext.Component component}
	/// {@link Ext.Component#id id} (see {@link #get}, or the convenience method {@link Ext#getCmp Ext.getCmp}).  This object also provides a registry of available Component classes
	/// indexed by a mnemonic code known as the Component&apos;s {@link Ext.Component#xtype xtype}.
	/// The {@link Ext.Component#xtype xtype} provides a way to avoid instantiating child Components
	/// when creating a full, nested config object for a complete Ext page.  A child Component may be specified simply as a config object
	/// as long as the correct {@link Ext.Component#xtype xtype} is specified so that if and when the Component
	/// needs rendering, the correct type can be looked up for lazy instantiation.  For a list of all available {@link Ext.Component#xtype xtypes}, see {@link Ext.Component}.
	/// </summary>
	/// <htmlSummary>
	/// &lt;p&gt;Provides a registry of all Components (instances of {@link Ext.Component} or any subclass
	/// thereof) on a page so that they can be easily accessed by {@link Ext.Component component}
	/// {@link Ext.Component#id id} (see {@link #get}, or the convenience method {@link Ext#getCmp Ext.getCmp}).&lt;/p&gt;
	/// &lt;p&gt;This object also provides a registry of available Component &lt;i&gt;classes&lt;/i&gt;
	/// indexed by a mnemonic code known as the Component&apos;s {@link Ext.Component#xtype xtype}.
	/// The &lt;code&gt;{@link Ext.Component#xtype xtype}&lt;/code&gt; provides a way to avoid instantiating child Components
	/// when creating a full, nested config object for a complete Ext page.&lt;/p&gt;
	/// &lt;p&gt;A child Component may be specified simply as a &lt;i&gt;config object&lt;/i&gt;
	/// as long as the correct &lt;code&gt;{@link Ext.Component#xtype xtype}&lt;/code&gt; is specified so that if and when the Component
	/// needs rendering, the correct type can be looked up for lazy instantiation.&lt;/p&gt;
	/// &lt;p&gt;For a list of all available &lt;code&gt;{@link Ext.Component#xtype xtypes}&lt;/code&gt;, see {@link Ext.Component}.&lt;/p&gt;
	/// </htmlSummary>
	/// <definedin>src\widgets\ComponentMgr.js</definedin>
	[ScriptName("ComponentMgr")]
	[ScriptNamespace("Ext")]
	[Imported()]
	public partial class ComponentMgr
	{
		
		#region Constructors
		/// <summary>Constructor</summary>
		internal ComponentMgr()
		{
		}
		#endregion
		
		#region Properties
		/// <summary>
		/// The MixedCollection used internally for the component cache. An example usage may be subscribing to
		/// events on the MixedCollection to monitor addition or removal. Read-only.
		/// </summary>
		/// <definedin>src\widgets\ComponentMgr.js</definedin>
		[ScriptName("all")]
		[IntrinsicProperty()]
		public System.Array All
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
		}
		
		/// <summary>The xtypes that have been registered with the component manager.</summary>
		/// <definedin>src\widgets\ComponentMgr.js</definedin>
		[ScriptName("types")]
		[IntrinsicProperty()]
		public object Types
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>The ptypes that have been registered with the component manager.</summary>
		/// <definedin>src\widgets\ComponentMgr.js</definedin>
		[ScriptName("ptypes")]
		[IntrinsicProperty()]
		public object Ptypes
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		#endregion
		
		#region Methods
		/// <summary>Registers a component.</summary>
		/// <definedin>src\widgets\ComponentMgr.js</definedin>
		/// <param name="c">The component</param>
		[ScriptName("register")]
		public void Register(ext.Component c)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Unregisters a component.</summary>
		/// <definedin>src\widgets\ComponentMgr.js</definedin>
		/// <param name="c">The component</param>
		[ScriptName("unregister")]
		public void Unregister(ext.Component c)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Returns a component by {@link Ext.Component#id id}.
		/// For additional details see {@link Ext.util.MixedCollection#get}.
		/// </summary>
		/// <definedin>src\widgets\ComponentMgr.js</definedin>
		/// <param name="id">The component {@link Ext.Component#id id}</param>
		/// <returns>
		/// The Component, <c>undefined</c> if not found, or <c>null</c> if a
		/// Class was found.
		/// </returns>
		[ScriptName("get")]
		public ext.Component Get(string id)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Registers a function that will be called when a Component with the specified id is added to ComponentMgr. This will happen on instantiation.</summary>
		/// <definedin>src\widgets\ComponentMgr.js</definedin>
		/// <param name="id">The component {@link Ext.Component#id id}</param>
		/// <param name="fn">The callback function</param>
		/// <param name="scope">The scope (<c>this</c> reference) in which the callback is executed. Defaults to the Component.</param>
		[ScriptName("onAvailable")]
		public void OnAvailable(string id, System.Delegate fn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Checks if a Component type is registered.</summary>
		/// <definedin>src\widgets\ComponentMgr.js</definedin>
		/// <param name="xtype">The mnemonic string by which the Component class may be looked up</param>
		/// <returns>Whether the type is registered.</returns>
		[ScriptName("isRegistered")]
		public bool IsRegistered(ext.Component xtype)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Checks if a Plugin type is registered.</summary>
		/// <definedin>src\widgets\ComponentMgr.js</definedin>
		/// <param name="ptype">The mnemonic string by which the Plugin class may be looked up</param>
		/// <returns>Whether the type is registered.</returns>
		[ScriptName("isPluginRegistered")]
		public bool IsPluginRegistered(ext.Component ptype)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Registers a new Component constructor, keyed by a new
		/// {@link Ext.Component#xtype}.  Use this method (or its alias {@link Ext#reg Ext.reg}) to register new
		/// subclasses of {@link Ext.Component} so that lazy instantiation may be used when specifying
		/// child Components.
		/// see {@link Ext.Container#items}
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Registers a new Component constructor, keyed by a new
		/// {@link Ext.Component#xtype}.&lt;/p&gt;
		/// &lt;p&gt;Use this method (or its alias {@link Ext#reg Ext.reg}) to register new
		/// subclasses of {@link Ext.Component} so that lazy instantiation may be used when specifying
		/// child Components.
		/// see {@link Ext.Container#items}&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\ComponentMgr.js</definedin>
		/// <param name="xtype">The mnemonic string by which the Component class may be looked up.</param>
		/// <param name="cls">The new Component class.</param>
		[ScriptName("registerType")]
		public void RegisterType(string xtype, System.Type cls)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Creates a new Component from the specified config object using the
		/// config object&apos;s {@link Ext.component#xtype xtype} to determine the class to instantiate.
		/// </summary>
		/// <definedin>src\widgets\ComponentMgr.js</definedin>
		/// <param name="config">A configuration object for the Component you wish to create.</param>
		/// <param name="defaultType">
		/// The constructor to provide the default Component type if
		/// the config object does not contain a <c>xtype</c>. (Optional if the config contains a <c>xtype</c>).
		/// </param>
		/// <returns>The newly instantiated Component.</returns>
		[ScriptName("create")]
		public ext.Component Create(object config, System.Type defaultType)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Registers a new Plugin constructor, keyed by a new
		/// {@link Ext.Component#ptype}.  Use this method (or its alias {@link Ext#preg Ext.preg}) to register new
		/// plugins for {@link Ext.Component}s so that lazy instantiation may be used when specifying
		/// Plugins.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Registers a new Plugin constructor, keyed by a new
		/// {@link Ext.Component#ptype}.&lt;/p&gt;
		/// &lt;p&gt;Use this method (or its alias {@link Ext#preg Ext.preg}) to register new
		/// plugins for {@link Ext.Component}s so that lazy instantiation may be used when specifying
		/// Plugins.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\ComponentMgr.js</definedin>
		/// <param name="ptype">The mnemonic string by which the Plugin class may be looked up.</param>
		/// <param name="cls">The new Plugin class.</param>
		[ScriptName("registerPlugin")]
		public void RegisterPlugin(string ptype, System.Type cls)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Creates a new Plugin from the specified config object using the
		/// config object&apos;s {@link Ext.component#ptype ptype} to determine the class to instantiate.
		/// </summary>
		/// <definedin>src\widgets\ComponentMgr.js</definedin>
		/// <param name="config">A configuration object for the Plugin you wish to create.</param>
		/// <param name="defaultType">
		/// The constructor to provide the default Plugin type if
		/// the config object does not contain a <c>ptype</c>. (Optional if the config contains a <c>ptype</c>).
		/// </param>
		/// <returns>The newly instantiated Plugin.</returns>
		[ScriptName("createPlugin")]
		public ext.Component CreatePlugin(object config, System.Type defaultType)
		{
			throw new System.Exception("Imported - not implemented");
		}
		#endregion
	}
}
